/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package modlemgooglesvn.modlem_src;

import java.awt.TextArea;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
import rsdm.rslib.data.MDataSet;


/**
 *
 * @author xXx
 */




public class ModlemAlgorytm {
double eval_new_p = 0;
String new_p = "";
 MDataSet G = null;
 
       public static void main(String[] args) throws IOException, InterruptedException {
          
String input = "D:\\ZBIORY_DANYCH\\data\\irysy - Copy.tab";

BufferedReader bf = new BufferedReader(new FileReader(input));

TextArea ta = new TextArea();
String s = "";
//while((s+=bf.readLine())!=null){}

    
    //
//StringTokenizer st = new StringTokenizer(input);
//ArrayList<ArrayList> lista = new ArrayList<ArrayList>();
MDataSet ms = new MDataSet();
ms.loadFromFile(bf);

ModlemAlgorytm ma = new ModlemAlgorytm();

ma.Modlem(ms, ms.getAttributeCount());
}


    
 
 
 
 
    public void Modlem(MDataSet tablica,int C){
     int typ = -1;
         G = tablica;
        ArrayList<String> P = new ArrayList<String>();
        
        while(G!=null){
        
            ArrayList<String> p = new ArrayList<String>();
            MDataSet S = G;
            
            while(p.isEmpty()){
            
                String w ="";
                double w_eval = Double.MAX_VALUE;
                int nrAtr = -1;
                for(int a = 0;a<C;a++){
                try{Double.parseDouble
                    (S.getAttributeValueAsString(a, 1));
                        typ = 0;}
                catch(NumberFormatException e){
                typ=1;
                }
////////////////////////////////////////////////                    find_Best_Condition(a, S, typ);
                
                    if(eval_new_p < w_eval){
                    w=a+","+new_p;
                    w_eval=eval_new_p;
                    nrAtr = a;
                    }
                }//end for
                boolean ograniczyl = false;
                p.add(w);
                 StringTokenizer st = new StringTokenizer(w,",");
                 String token = st.nextToken();
                 double liczba = -0.00000000000000000000000915;
                 String tekst = "gomenasai";
                 if(token.equalsIgnoreCase("w")){//wiekszę równe
                       liczba = Double.parseDouble(st.nextToken());
                       
                   }
                   else if (token.equalsIgnoreCase("m")){//mniejse
                       liczba = Double.parseDouble(st.nextToken());
                   }
                   else if(token.equalsIgnoreCase("r")){//równe
                       tekst = st.nextToken();
                       
                   }
                   else System.out.println("Error w ograniczaniu zbioru S");
                 
                 if(liczba!=-0.00000000000000000000000915){
                     
                for(int i = 0 ; i<S.getDataRecordCount();i++){
                    if(S.getAttributeValueAsDouble(i,nrAtr)>=liczba){
                        
                    }else{
                        
                    S.buildDataSetWithoutOneRecord(i);
                        ograniczyl=true;
                    
                }
                 }
                 }
                 
                 else if(!tekst.equalsIgnoreCase("gomenasai")) {
                     
                                     for(int i = 0 ; i<S.getDataRecordCount();i++){
                  if(S.getDataRecord(i).getAttributeValue(nrAtr).toString().equalsIgnoreCase(tekst)){
                      
                    }else{
                        
                    S.buildDataSetWithoutOneRecord(i);
                        ograniczyl=true;
                    }
                }
                 }
                 
                 if(ograniczyl==false){
                 p.remove(p.size());
                 break;
                 }
                 
            }//end while(p.isEmpty())   || !P=(podzbior)K
            
            
            for(int i = 0 ;i<p.size();i++){
            StringTokenizer st = new StringTokenizer(p.get(i).toString(),",");
            int atr = Integer.parseInt(st.nextToken());
            String operator = st.nextToken();
            String token =st.nextToken();
            Double wartosc = -0.00000000000000091;
            String wartoscString = "";
            try{
            wartosc = Double.parseDouble(token);
            }
            catch(NumberFormatException e){
            wartoscString = token;
            }
            if(wartosc!=null || wartosc != -0.00000000000000091){
            
                for(int m= 0 ; m < P.size();m++)
                {
                ArrayList<String> mm = P;
                mm.remove(m);
                for(int x = 0; x< tablica.getDataRecordCount();x++){

                 
                for(int l = 0;l<mm.size();l++){
                StringTokenizer stt = new StringTokenizer(mm.get(l), ",");
                    //p=atr+","+><=","wartosc;
                 int at = Integer.parseInt(stt.nextToken());
                 String znak = stt.nextToken();
                 Double val = Double.parseDouble(stt.nextToken());
                    int kt = 0;
                    if(znak.equalsIgnoreCase(">="))kt=0;
                    else if(znak.equalsIgnoreCase("<"))kt=1;
                    else kt=2;
                 switch(kt){
                 
                     case 0 : {
                     
                         
                         if(tablica.getAttributeValueAsDouble(x,at)>=val);
                         else
                         
                         break;
                     }
                         
                          case 1 : {
                     
                         break;
                     }
                              
                               case 2 : {
                     
                         break;
                     }
                         
                         
                 
                 }
                 
                    
                }
                 
                }
                    
                
                }
            
            }//end if(wartosc!=null || wartosc != -0.00000000000000091)
            }//end  for(int i = 0 ;i<p.size();i++){
            
        }//end while(!G.isEmpty())
        
        
    }//end Modlem'
    
    

    
    
    
    
}//Skasować później jak odblokuje findbest .....






//    public void find_Best_Condition(int a,ArrayList<ArrayList> SS, int typ){
//        String best_t="";
//        double eval_best_t=Double.MAX_VALUE;
//        ArrayList S1 = null , S2 = null;
//        ArrayList S = SS.get(a);
//        Collections.sort(S);
//        double eval_t = 0.0;
//        double v = 0.0;
//        String vv = "";
//        for(int i =0 ; i<S.size();i++){
//        if(S.get(i).toString().equalsIgnoreCase(S.get(i+1).toString())){
//        S.remove(i+1);
//        }
//        }
//    switch(typ){
//    
//        case 0 :{
//        
//            for(int i =0;i<S.size()-1;i++){
//                
//                v = (Double)S.get(i)+(Double)S.get(i+1);
//                
//                if((Double)SS.get(a).get(i)>=v){
//                S2.add(SS.get(a).get(i));
//                
//                }
//                else S1.add(SS.get(a).get(i));
//                eval_t = S1.size()/S1.size()+S2.size()*Entropia(S1)+S2.size()/S1.size()+S2.size()*Entropia(S2);
//            
//                if(eval_t<eval_best_t){
//                int s1=0,s2=0;
//                    for(int j = 0; j< G.get(a).size();j++){
//                    for(int k = 0 ;k<S2.size();k++){
//                    
//                       if( G.get(a).get(j).equals(S2.get(k)))
//                           s2++;
//                        
//                    
//                    }
//                    
//                    for(int k = 0 ;k<S1.size();k++){
//                    
//                       if( G.get(a).get(j).equals(S1.get(k)))
//                           s1++;
//                    
//                    }
//                    
//                    }//end  for(int j = 0; j< G.get(a).size();j++)
//                if(s2>=s1)
//                    best_t= ">=,"+v;
//                    else
//                    best_t="<,"+v;
//                
//                eval_best_t=eval_t;
//                    
//               
//                    
//                }//end (eval_t<eval_best_t)
//                
//            }//end for(int i =0;i<S.size()-1;i++)
//            new_p=best_t;
//            eval_new_p=eval_best_t;
//            break;
//        }//end case 0
//            
//        case 1: {
//            
//                        for(int i =0;i<S.size()-1;i++){
//                
//                vv = S.get(i).toString();
//                
//                if(SS.get(a).get(i).toString().equalsIgnoreCase(vv)){
//                S2.add(SS.get(a).get(i));
//                
//                }
//                else S1.add(SS.get(a).get(i));
//                eval_t = S1.size()/S1.size()+S2.size()
//                        *Entropia(S1)+S2.size()/S1.size()+S2.size()
//                        *Entropia(S2);
//            
//                if(eval_t<eval_best_t){
//                int s1=0,s2=0;
//                    for(int j = 0; j< G.get(a).size();j++){
//                    for(int k = 0 ;k<S2.size();k++){
//                    
//                       if( G.get(a).get(j).equals(S2.get(k)))
//                           s2++;
//                        
//                    
//                    }
//                    
//                    for(int k = 0 ;k<S1.size();k++){
//                    
//                       if( G.get(a).get(j).equals(S1.get(k)))
//                           s1++;
//                    
//                    }
//                    
//                    }//end  for(int j = 0; j< G.get(a).size();j++)
//                if(s2>=s1)
//                    best_t= "=,"+vv;
//                    else
//                    best_t="<!=,"+vv;
//                
//                eval_best_t=eval_t;
//                    
//               
//                    
//                }//end (eval_t<eval_best_t)
//                
//            }//end for(int i =0;i<S.size()-1;i++)
//                        new_p=best_t;
//            eval_new_p = eval_best_t;
//             break;
//        }//end case 1
//            
//        case -1:{
//        
//        System.out.println("Problem w find_Best_Condition : -1");
//         break;
//        }//end case -1
//        default:{
//        System.out.println("Problem w find_Best_Condition : default");
//         break;
//        }
//    
//    }
//    
//    
//    }
//    
//    public static Double Entropia(ArrayList obiekty){
//    
//    Double ent = 0.0;
//    int[] entropia = new int[obiekty.size()];
//    int k=0;
//    for(int i=0;i<obiekty.size();i++){
//        
//        for(int j=0;j<obiekty.size();j++){
//        
//            if(obiekty.get(i).equals(obiekty.get(j)))
//                    {
//                entropia[i]++;        
//                    }
//            else
//               
//                ;
//        }
//    if(entropia[i]==0)
//    entropia[i]=1;
//    }
//    for(int i=0;i<obiekty.size();i++){
//    
//       ent=ent + (entropia[i]/obiekty.size()*Math.log(entropia[i]/obiekty.size()));
//    
//    }
//    
//    return -ent;
//    }
//    
//    
//}//end class ModlemAlgorytm
//
//class MDataSetExt extends MDataSet{
//    
//    
//    
////    public void deleteRecord(int i){
////    
////        MDataSet ms = new MDataSet();
////        
////        dataRecordList.remove(i);
////    }
//
//}
